{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TensorFlow version: 2.0.0\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import datetime, os\n",
    "# hide tf logs\n",
    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'  # or any {'0', '1', '2'},\n",
    "# 0 (default) shows all, 1 to filter out INFO logs, 2 to additionally filter out WARNING logs, and 3 to additionally filter out ERROR logs\n",
    "import scipy.optimize\n",
    "import scipy.io\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker\n",
    "import time\n",
    "from pyDOE import lhs         #Latin Hypercube Sampling\n",
    "import pandas as pd\n",
    "import seaborn as sns \n",
    "import codecs, json\n",
    "\n",
    "# generates same random numbers each time\n",
    "np.random.seed(1234)\n",
    "tf.random.set_seed(1234)\n",
    "\n",
    "print(\"TensorFlow version: {}\".format(tf.__version__))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Prep\n",
    "\n",
    "Training and Testing data is prepared from the solution file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_1 = np.linspace(-1,1,256)  # 256 points between -1 and 1 [256x1]\n",
    "x_2 = np.linspace(1,-1,256)  # 256 points between 1 and -1 [256x1]\n",
    "\n",
    "X, Y = np.meshgrid(x_1,x_2) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test Data\n",
    "\n",
    "We prepare the test data to compare against the solution produced by the PINN."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_u_test = np.hstack((X.flatten(order='F')[:,None], Y.flatten(order='F')[:,None]))\n",
    "\n",
    "# Domain bounds\n",
    "lb = np.array([-1, -1]) #lower bound\n",
    "ub = np.array([1, 1])  #upper bound\n",
    "\n",
    "a_1 = 1 \n",
    "a_2 = 1\n",
    "\n",
    "usol = np.sin(a_1 * np.pi * X) * np.sin(a_2 * np.pi * Y) #solution chosen for convinience  \n",
    "\n",
    "u = usol.flatten('F')[:,None] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plot and save true solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plt.pcolor(x_1,x_2,usol, cmap = 'jet')\n",
    "# plt.axis('scaled')\n",
    "# plt.colorbar()\n",
    "# fig.savefig('Helmholtz_non_stiff_true.png', bbox_inches='tight', dpi = 500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def trainingdata(N_u,N_f):\n",
    "    \n",
    "    leftedge_x = np.hstack((X[:,0][:,None], Y[:,0][:,None]))\n",
    "    leftedge_u = usol[:,0][:,None]\n",
    "    \n",
    "    rightedge_x = np.hstack((X[:,-1][:,None], Y[:,-1][:,None]))\n",
    "    rightedge_u = usol[:,-1][:,None]\n",
    "    \n",
    "    topedge_x = np.hstack((X[0,:][:,None], Y[0,:][:,None]))\n",
    "    topedge_u = usol[0,:][:,None]\n",
    "    \n",
    "    bottomedge_x = np.hstack((X[-1,:][:,None], Y[-1,:][:,None]))\n",
    "    bottomedge_u = usol[-1,:][:,None]\n",
    "    \n",
    "    all_X_u_train = np.vstack([leftedge_x, rightedge_x, bottomedge_x, topedge_x])\n",
    "    all_u_train = np.vstack([leftedge_u, rightedge_u, bottomedge_u, topedge_u])  \n",
    "     \n",
    "    #choose random N_u points for training\n",
    "    idx = np.random.choice(all_X_u_train.shape[0], N_u, replace=False) \n",
    "    \n",
    "    X_u_train = all_X_u_train[idx[0:N_u], :] #choose indices from  set 'idx' (x,t)\n",
    "    u_train = all_u_train[idx[0:N_u],:]      #choose corresponding u\n",
    "    \n",
    "    '''Collocation Points'''\n",
    "\n",
    "    # Latin Hypercube sampling for collocation points \n",
    "    # N_f sets of tuples(x,t)\n",
    "    X_f = lb + (ub-lb)*lhs(2,N_f) \n",
    "    X_f_train = np.vstack((X_f, X_u_train)) # append training points to collocation points \n",
    "    \n",
    "    return X_f_train, X_u_train, u_train "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PINN \n",
    "\n",
    "$W \\in \\mathcal{R}^{n_{l-1}\\times{n_l}}$ \n",
    "\n",
    "Creating sequential layers using the $\\textit{class}$ tf.Module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Sequentialmodel(tf.Module): \n",
    "    def __init__(self, layers, name=None):\n",
    "\n",
    "        self.W = []  # Weights and biases\n",
    "        self.parameters = 0 # total number of parameters\n",
    "\n",
    "        for i in range(len(layers)-1):\n",
    "\n",
    "            input_dim = layers[i]\n",
    "            output_dim = layers[i+1]\n",
    "\n",
    "            #Xavier standard deviation \n",
    "            std_dv = np.sqrt((2.0/(input_dim + output_dim)))\n",
    "\n",
    "            #weights = normal distribution * Xavier standard deviation + 0\n",
    "            w = tf.random.normal([input_dim, output_dim], dtype = 'float64') * std_dv\n",
    "\n",
    "            w = tf.Variable(w, trainable=True, name = 'w' + str(i+1))\n",
    "\n",
    "            b = tf.Variable(tf.cast(tf.zeros([output_dim]), dtype = 'float64'), trainable = True, name = 'b' + str(i+1))\n",
    "\n",
    "            self.W.append(w)\n",
    "            self.W.append(b)\n",
    "\n",
    "            self.parameters +=  input_dim * output_dim + output_dim\n",
    "            \n",
    "            \n",
    "    def evaluate(self,x):\n",
    "        \n",
    "        # pre-processing input \n",
    "        x = (x - lb)/(ub - lb) #feature scaling\n",
    "        \n",
    "        a = x\n",
    "        \n",
    "        for i in range(len(layers)-2):\n",
    "            \n",
    "            z = tf.add(tf.matmul(a, self.W[2*i]), self.W[2*i+1])\n",
    "            a = tf.nn.tanh(z)\n",
    "            \n",
    "        a = tf.add(tf.matmul(a, self.W[-2]), self.W[-1]) # For regression, no activation to last layer\n",
    "        \n",
    "        return a\n",
    "    \n",
    "    def get_weights(self):\n",
    "\n",
    "        parameters_1d = []  # [.... W_i,b_i.....  ] 1d array\n",
    "        \n",
    "        for i in range (len(layers)-1):\n",
    "            \n",
    "            w_1d = tf.reshape(self.W[2*i],[-1])   #flatten weights \n",
    "            b_1d = tf.reshape(self.W[2*i+1],[-1]) #flatten biases\n",
    "            \n",
    "            parameters_1d = tf.concat([parameters_1d, w_1d], 0) #concat weights \n",
    "            parameters_1d = tf.concat([parameters_1d, b_1d], 0) #concat biases\n",
    "        \n",
    "        return parameters_1d\n",
    "        \n",
    "    def set_weights(self,parameters):\n",
    "                \n",
    "        for i in range (len(layers)-1):\n",
    "\n",
    "            shape_w = tf.shape(self.W[2*i]).numpy() # shape of the weight tensor\n",
    "            size_w = tf.size(self.W[2*i]).numpy() #size of the weight tensor \n",
    "            \n",
    "            shape_b = tf.shape(self.W[2*i+1]).numpy() # shape of the bias tensor\n",
    "            size_b = tf.size(self.W[2*i+1]).numpy() #size of the bias tensor \n",
    "                        \n",
    "            pick_w = parameters[0:size_w] #pick the weights \n",
    "            self.W[2*i].assign(tf.reshape(pick_w,shape_w)) # assign  \n",
    "            parameters = np.delete(parameters,np.arange(size_w),0) #delete \n",
    "            \n",
    "            pick_b = parameters[0:size_b] #pick the biases \n",
    "            self.W[2*i+1].assign(tf.reshape(pick_b,shape_b)) # assign \n",
    "            parameters = np.delete(parameters,np.arange(size_b),0) #delete \n",
    "\n",
    "            \n",
    "    def loss_BC(self,x,y):\n",
    "\n",
    "        loss_u = tf.reduce_mean(tf.square(y-self.evaluate(x)))\n",
    "        return loss_u\n",
    "\n",
    "    def loss_PDE(self, x_to_train_f):\n",
    "    \n",
    "        g = tf.Variable(x_to_train_f, dtype = 'float64', trainable = False)\n",
    "\n",
    "        k = 1    \n",
    "\n",
    "        x_1_f = g[:,0:1]\n",
    "        x_2_f = g[:,1:2]\n",
    "\n",
    "        with tf.GradientTape(persistent=True) as tape:\n",
    "\n",
    "            tape.watch(x_1_f)\n",
    "            tape.watch(x_2_f)\n",
    "\n",
    "            g = tf.stack([x_1_f[:,0], x_2_f[:,0]], axis=1)\n",
    "\n",
    "            u = self.evaluate(g)\n",
    "            u_x_1 = tape.gradient(u,x_1_f)\n",
    "            u_x_2 = tape.gradient(u,x_2_f)\n",
    "\n",
    "        u_xx_1 = tape.gradient(u_x_1,x_1_f)\n",
    "        u_xx_2 = tape.gradient(u_x_2,x_2_f)\n",
    "\n",
    "        del tape\n",
    "\n",
    "        q = -( (a_1*np.pi)**2 + (a_2*np.pi)**2 - k**2 ) * np.sin(a_1*np.pi*x_1_f) * np.sin(a_2*np.pi*x_2_f)\n",
    "\n",
    "        f = u_xx_1 + u_xx_2 + k**2 * u - q #residual\n",
    "\n",
    "        loss_f = tf.reduce_mean(tf.square(f))\n",
    "\n",
    "        return loss_f, f\n",
    "    \n",
    "    def loss(self,x,y,g):\n",
    "\n",
    "        loss_u = self.loss_BC(x,y)\n",
    "        loss_f, f = self.loss_PDE(g)\n",
    "\n",
    "        loss = loss_u + loss_f\n",
    "\n",
    "        return loss, loss_u, loss_f \n",
    "    \n",
    "    def optimizerfunc(self,parameters):\n",
    "        \n",
    "        self.set_weights(parameters)\n",
    "       \n",
    "        with tf.GradientTape() as tape:\n",
    "            tape.watch(self.trainable_variables)\n",
    "            \n",
    "            loss_val, loss_u, loss_f = self.loss(X_u_train, u_train, X_f_train)\n",
    "            \n",
    "        grads = tape.gradient(loss_val,self.trainable_variables)\n",
    "                \n",
    "        del tape\n",
    "        \n",
    "        grads_1d = [ ] #store 1d grads \n",
    "        \n",
    "        for i in range (len(layers)-1):\n",
    "\n",
    "            grads_w_1d = tf.reshape(grads[2*i],[-1]) #flatten weights \n",
    "            grads_b_1d = tf.reshape(grads[2*i+1],[-1]) #flatten biases\n",
    "\n",
    "            grads_1d = tf.concat([grads_1d, grads_w_1d], 0) #concat grad_weights \n",
    "            grads_1d = tf.concat([grads_1d, grads_b_1d], 0) #concat grad_biases\n",
    "        \n",
    "        return loss_val.numpy(), grads_1d.numpy()\n",
    "    \n",
    "    def optimizer_callback(self,parameters):\n",
    "                \n",
    "        loss_value, loss_u, loss_f = self.loss(X_u_train, u_train, X_f_train)\n",
    "        \n",
    "        u_pred = self.evaluate(X_u_test)\n",
    "        error_vec = np.linalg.norm((u-u_pred),2)/np.linalg.norm(u,2)\n",
    "        \n",
    "        tf.print(loss_value, loss_u, loss_f, error_vec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Main"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "N_u = 400 #Total number of data points for 'u'\n",
    "N_f = 10000 #Total number of collocation points \n",
    "\n",
    "# Training data\n",
    "X_f_train, X_u_train, u_train = trainingdata(N_u,N_f)\n",
    "\n",
    "layers = np.array([2, 50, 1]) #1 hidden layer\n",
    "\n",
    "PINN = Sequentialmodel(layers)\n",
    "\n",
    "init_params = PINN.get_weights().numpy()\n",
    "\n",
    "start_time = time.time() \n",
    "\n",
    "# train the model with Scipy L-BFGS optimizer\n",
    "results = scipy.optimize.minimize(fun = PINN.optimizerfunc, \n",
    "                                  x0 = init_params, \n",
    "                                  args=(), \n",
    "                                  method='L-BFGS-B', \n",
    "                                  jac= True,        # If jac is True, fun is assumed to return the gradient along with the objective function\n",
    "                                  callback = PINN.optimizer_callback, \n",
    "                                  options = {'disp': None,\n",
    "                                            'maxcor': 10, \n",
    "                                            'ftol': 1 * np.finfo(float).eps,  #The iteration stops when (f^k - f^{k+1})/max{|f^k|,|f^{k+1}|,1} <= ftol\n",
    "                                            'gtol': 5e-10, \n",
    "                                            'maxfun':  50000, \n",
    "                                            'maxiter': 5000,\n",
    "                                            'iprint': -1,   # no iteration updates\n",
    "                                            'maxls': 50})\n",
    "\n",
    "elapsed = time.time() - start_time                \n",
    "print('Training time: %.2f' % (elapsed))\n",
    "\n",
    "print(results)\n",
    "\n",
    "PINN.set_weights(results.x)\n",
    "\n",
    "''' Model Accuracy ''' \n",
    "u_pred = PINN.evaluate(X_u_test)\n",
    "\n",
    "error_vec = np.linalg.norm((u-u_pred),2)/np.linalg.norm(u,2)        # Relative L2 Norm of the error (Vector)\n",
    "print('Test Error: %.5f'  % (error_vec))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Building the Hessian matrix\n",
    "\n",
    "[Refer TensorFlow 2.3 Documentation Example](https://www.tensorflow.org/guide/advanced_autodiff#example_hessian)\n",
    "\n",
    "What is the 'block' matrix?\n",
    "\n",
    "A matrix of tuples representing the dimensions of sub-hessians and to track indices while assembling the Hessian using sub-hessians\n",
    "\n",
    "Sub-hessians: $ \\frac{1}{\\partial^{W^{[l]}}} \\big( \\frac{\\partial loss}{\\partial^{W^{[l]}}} \\big )$\n",
    "\n",
    "Each column contains the matrix $\\frac{\\partial loss}{\\partial^{W^{[l]}}}$\n",
    "\n",
    "Each row contains kernel $W^{[l]}$\n",
    "\n",
    "Each matrix element is a tensor of size (kernel[i].shape, kernel[j].shape) \n",
    "\n",
    "Example: kernel shape:(5,4), shape of matrix $\\frac{\\partial loss}{\\partial^{W^{[l]}}}$: (2,3)\n",
    "\n",
    "shape of sub-Hessian: (5,4,2,3)  \n",
    "\n",
    "We reduce the shape of theses higher order tensors into 2D tensors using tf.reshape\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_kernels = (len(layers)-1)*2 # total number of weight and bias tensors\n",
    "\n",
    "block = np.zeros((num_kernels,num_kernels),object) \n",
    "\n",
    "for j in range(num_kernels):\n",
    "    for i in range(j+1):\n",
    "        \n",
    "        if i == j:\n",
    "            s = tf.reduce_prod(PINN.W[i].shape)\n",
    "            block[i,j] = (s.numpy(),s.numpy())\n",
    "        else:\n",
    "            block[j,i] = (PINN.W[j].shape[0], tf.reduce_prod(PINN.W[i].shape).numpy())\n",
    "            block[i,j] = block[j,i]     \n",
    "            \n",
    "print(block)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Computation and assembly of sub-hessians"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialise Hessian \n",
    "# N x N square matrix , N = total number of parameters\n",
    "H = np.zeros((PINN.parameters,PINN.parameters)) \n",
    "\n",
    "# pointer to mark position of sub-hessian assembly \n",
    "pointer = np.array([0, 0]) # coordinates to upper left corner element of current block\n",
    "\n",
    "for j in range(num_kernels):\n",
    "    for i in range(j+1):\n",
    "\n",
    "        with tf.GradientTape() as tape2:\n",
    "            with tf.GradientTape() as tape1:\n",
    "                loss_value, loss_u, loss_f = PINN.loss(X_u_train, u_train, X_f_train)\n",
    "\n",
    "            g = tape1.gradient(loss_value, PINN.W[i]) #sub-gradient , n_in * n_out\n",
    "\n",
    "        h = tape2.jacobian(g,PINN.W[j]) # sub-hessian \n",
    "\n",
    "        #diagonal term\n",
    "        if i == j :\n",
    "            # reshape higher order tensor into 2D tensor\n",
    "            h_mat = tf.reshape(h, block[j,i]) # [?]\n",
    "            \n",
    "            # shape of block, block is square for diagonal terms\n",
    "            block_shape = h_mat.shape\n",
    "            \n",
    "            # Assemble block in H matrix\n",
    "            # position of assembly determined by 'pointer' and size of block\n",
    "            H[pointer[0]:pointer[0]+block_shape[0], pointer[1]:pointer[1]+block_shape[1]] = h_mat\n",
    "            \n",
    "            # move pointer to new poistion\n",
    "            # move to next row ---> determined by number of rows in current block\n",
    "            pointer[0] = pointer[0] + block_shape[0]\n",
    "            pointer[1] = 0\n",
    "            \n",
    "        #non-diagonal term    \n",
    "        else:\n",
    "            # reshape higher order tensor into 2D tensor\n",
    "            h_mat = tf.reshape(h, block[j,i]) \n",
    "            \n",
    "            # shape of block\n",
    "            block_shape = h_mat.shape\n",
    "            \n",
    "            # Assemble block in H matrix\n",
    "            # position of assembly determined by 'pointer' and size of block\n",
    "            H[pointer[0]:pointer[0]+block_shape[0], pointer[1]:pointer[1]+block_shape[1]] = h_mat\n",
    "            \n",
    "            # Assemble symmteric part by switching indices and transposing the block\n",
    "            H[pointer[1]:pointer[1]+block_shape[1], pointer[0]:pointer[0]+block_shape[0]] = tf.transpose(h_mat)\n",
    "            \n",
    "            # move pointer to new poistion\n",
    "            # move to next column ---> determined by number of columns in current block\n",
    "            pointer[1] = pointer[1] + block_shape[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Compute Eigenvalues\n",
    "\n",
    "In this section we use the hermitian property of the Hessian and the approx Hessian inverse matrices and compute their eigenvalues using the 'tf.linalg.eigvalsh()' method and plot them for comparison"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eigenvalues of Hessian (H) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "H = tf.convert_to_tensor(H, dtype = tf.float32)\n",
    "v_hess = tf.linalg.eigvalsh(H)\n",
    "\n",
    "np.savetxt(\"hess_eigvals.txt\", v_hess)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eigenvalues of L-BFGS approximation of Hessian (B) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B =  results.hess_inv.todense() # hessian estimate\n",
    "B = tf.convert_to_tensor(B, dtype = tf.float32)\n",
    "\n",
    "v_approx_hess = tf.linalg.eigvalsh(B)\n",
    "\n",
    "np.savetxt(\"approx_hess_eigvals.txt\", v_approx_hess)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "product = tf.linalg.matmul(H,B)\n",
    "\n",
    "v_product = tf.linalg.eigvals(product)\n",
    "\n",
    "np.savetxt(\"approx_product_eigvals.txt\", v_product)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "### Load Data ###\n",
    "\n",
    "# non-stiff problem \n",
    "v_hess = np.loadtxt(\"prove_stiffness/max_cor_10/hess_eigvals.txt\")\n",
    "v_approx_hess = np.loadtxt(\"prove_stiffness/max_cor_10/approx_hess_eigvals.txt\")\n",
    "\n",
    "# stiff problem\n",
    "v_hess_stiff = np.loadtxt(\"prove_stiffness/max_cor_10/hess_eigvals_stiff.txt\")\n",
    "v_approx_hess_stiff = np.loadtxt(\"prove_stiffness/max_cor_10/approx_hess_eigvals_stiff.txt\")\n",
    "\n",
    "# product \n",
    "product = np.loadtxt(\"prove_stiffness/max_cor_10/product_eigvals.txt\")\n",
    "product_stiff = np.loadtxt(\"prove_stiffness/max_cor_10/product_eigvals_stiff.txt\")\n",
    "\n",
    "### Plotting ###\n",
    "\n",
    "fig,ax = plt.subplots()\n",
    "\n",
    "# non-stiff problem\n",
    "plt.plot(v_hess, '--', label = '$\\lambda(H_k)$ non-stiff', color = 'red')\n",
    "plt.plot(v_approx_hess, '--', label = '$\\lambda(B_k^{-1})$ non-stiff', color = 'green')\n",
    "\n",
    "# stiff problem\n",
    "plt.plot(v_hess_stiff, label = '$\\lambda(H_k)$ stiff', color = 'red')\n",
    "plt.plot(v_approx_hess_stiff, label = '$\\lambda(B_k^{-1})$ stiff', color = 'green')\n",
    "\n",
    "plt.plot(product, label = '$\\lambda(H_k B_k^{-1})$ Non-stiff')\n",
    "plt.plot(product_stiff, label = '$\\lambda(H_k B_k^{-1})$ stiff')\n",
    "\n",
    "ax.set_yscale('symlog')\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "\n",
    "# plt.savefig('prove_stiffness/max_cor_10/eigenvalues_compare_max_cor_10.png', dpi = 500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX8AAAD4CAYAAAAEhuazAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABDXElEQVR4nO3dd3yUVfb48c9NIyGBUEIJvSNNikgUC7hKUVEB/bGoiIjo2nVdWQRRQVR07aIUFQQsgGCBRQFhCcUvikgxhRqQEjqhhCQkk0zu7487CQmpk8zMM5mcN695JTNPO3kSTp48c+85SmuNEEKIysXP6gCEEEJ4niR/IYSohCT5CyFEJSTJXwghKiFJ/kIIUQkFWB1AaUREROhmzZqVefvU1FRCQ0NdF5CLSFzOkbicI3E5xxfj2rx58ymtdZ1CF2qtvf5xxRVX6PKIjo4u1/buInE5R+JyjsTlHF+MC/hDF5FX5baPEEJUQpL8hRCiEpLkL4QQlVCFeMO3MJmZmSQmJpKenl7iuuHh4ezYscMDUTlH4jKCg4Np1KgRgYGBHjumEJVdhU3+iYmJVKtWjWbNmqGUKnbd8+fPU61aNQ9FVnoSlxlwkJSURGJiIs2bN/fIMYUQFt32UUr5KaVeU0pNUUrdX5Z9pKenU7t27RITv/BuSilq165dqr/ghBCu47Lkr5SapZQ6oZSKu+T1/kqpXUqpBKXU846X7wAaAZlAYjmOWfaAhdeQ76MQnufKK//ZQP+8Lyil/IGPgZuB9sDdSqn2QFtgg9b6WeBRF8YghBA+I3PWp9RbudIt+3bZPX+t9TqlVLNLXu4BJGit9wEopeZjrvoPATbHOvbC9qeUehh4GKBevXqsWbMm3/Lw8HDOnz9fqtjsdnup1/Ukieui9PT0At/jS6WkpJS4jhUkLudIXKWj7HY+/t8TpIdV5dk1fVy+f3e/4dsQk+hzJAJRwAfAFKXUdcC6wjbUWn8CfALQvXt33bt373zLd+zYUeo3JeWNVedYEVdwcDBdu3Ytdp01a9Zw6c+BN5C4nCNxlc7hRZ/zfUsb9wR0d0tclrzhq7VO01o/qLV+Umv9sRUxuEpsbCxNmzZl2rRp+V6/cOECvXr1wm43f9jMmDGDRx/Nf4crKiqq0CGVNpuN66+/nqysLPcFXgpnz55l6tSp+V7r2bNn7ucffvgh7dq149577y30uRCi7KavfB27H/Tv9ohb9u/u5H8YaJzneSPHaz6jU6dOzJ8/n7lz5+Z7fdasWQwePBh/f3/A/JLo1q1b7vL09HQOHjxImzZtCuwzKCiIG2+8kQULFrg3+BIUlvw3bNiQ+/nUqVNZuXIlX331VaHPhRBlk/7XHmaEJ3Cbbk1kWOOSNygDdyf/TUBrpVRzpVQQMBRY4uZjelzdunWJj4/P99pXX33FHXfckfs8JiYmX/KPjY2lVatWub8cLjVw4MBCk+j+/ftp164dDz30EB06dKBv375cuHABgHfffZeOHTvSsWNH3n///RLXzys1NZVbb72Vzp07ExUVxYIFC3j++efZu3cvXbp0YfTo0QCEhYUB8Mgjj7Bv3z5uvvlm3nvvvQLPhRBlF718OidD4ZHr/um2Y7jsnr9Sah7QG4hQSiUCL2utZyqlngBWAP7ALK11fDG7KbvC7okNGQKPPQZpaXDbbQWXjxhhHqdOwV135V/mxBs/zz//PBkZGRw4cICmTZtis9nYt28fectQx8fHM3jw4NxhjSkpKfTr16/IfXbs2JFNmzYVumzPnj3MmzePTz/9lCFDhvDtt9/Srl07Pv/8czZu3IjWmqioKHr16kXNmjULXX/YsGH59rl8+XIaNGjAjz/+yPnz58nOziYqKoq4uDi2bdtWIIbp06ezfPlyoqOjiYiIyN1H3udCiLLZuW8jhMGVUYOJ2+ye2fYuu/LXWt+ttY7UWgdqrRtprWc6Xv9Ja91Ga91Sa/2aq47nLZYtW5Z71Zxz9X/q1Clq1KiRu86hQ4eoU6cOBw4cYP/+/ezfv5+hQ4fSoUMHAEaOHFlgv/7+/gQFBRU66qZ58+Z06dIFgCuuuIL9+/fzyy+/MGjQIEJDQwkLC2Pw4MGsX7++yPUv1alTJ1auXMmYMWPYsGED4eHh5TgrQojy2HV6D7UyA4ioVs9tx6iw5R0KKO5KvWrV4pdHRDh1pZ8jPT2dMWPGsGTJEj7//HPi4uK45ZZbCAkJyTdjNTY2NjfR59i+fTt9+vQhLS2N8PBwoqOjWb58ORMnTiQ4OBiAjIyM3M/zqlKlSu7n/v7+hd7GKc36H3/8MZ9++ikAP/30E1u2bOGnn35i0qRJbNy4keHDhzt5RoQQ5ZaZyS59krZ+9d16GKnqWQ6vvvoqw4cPp1mzZnTq1Im4ODO5uWbNmtjt9txfADExMbRv3z7ftvHx8XTo0IEtW7awdetWdu3axZtvvpmb7JOSkoiIiCh1sbPrrruOH374gbS0NFJTU/n++++57rrrit3m8ccfZ9u2bbm3dapWrcqwYcN46qmn2LJlC9WqVfPKeQhC+LS4OHbV0rStWXAwiCtJ8i+jXbt2sXLlSp555hmAfMkfoG/fvvzyyy+AufLPm/xPnz6N1pp69eqxadMmoqKiCrRpi46O5tZbby11PN26dWPEiBH06NGDqKgoRo0aVeK4+bxiY2Pp0aMHXbp04Y033mD8+PHUrl2ba665ho4dO+a+4SuEcK/k39dztBq0bXGlew9UVIsvb3oU1sZx+/btpW5llpycXOp1XWXz5s162LBhxa6TnJysR40ape12ux43bpxet25d7rJBgwbpXbt2uTvMIuPytNJ8P32xzZ47SVzO8Za4Nj0+SDMB/W38Iq21+9o4+s49fy/TrVs3brjhBux2e5HDOYHce+6vvXbxvXCbzcbAgQMLnQMghPBhaWnsjlsLN0DbiMvceiirSjr3VkqtV0pNV0r1tiIGTxg5cmSxib8oQUFB8marEJXRpEnsUqfxw49WtVq59VBWlXTWQAoQTDlKOgshhE/QGr7+Gt5+m11XNqdZzWZUCahS8nblYFVJ5/Va65uBMcBEF8YghBAVS3Iy9OsH994LnTsT0yiQdhHtALiQWfww7vJQ5j0BF+3MlHReqrXu6Hh+NTBBa93P8XwsgNZ6suN5EPC11vquQvaVt6TzFfPnz8+3PDw8nFatSvdnUUn33a0icV2UkJDAuXPnil0nJSUlt7yEN5G4nCNxXVT1wAEumzyZsIQEEp58kth+Pblr4xDuaXwP8cnxJKQk8MXlX1Czes0y7f+GG27YrLXuXtgyS0o6K6UGA/2AGsBHhW2opaSzZaSks3MkLudU+rh++w3eeQf27IE//4SQEPjhB9oMGMDvMV+adcJh3/F9/LPnPwnMDnRLXJaM9tFafwd8Z8WxhRDCMh99BP/8J9SuDV27wtChMHIk1K0LwKp9q6gdUpvZA2ez89ROOtXr5LYGM+5O/j5f0lkIIUrl++/hySfh9tthzhzIU/8LzJyrn/f+zLVNriXQP5BO9Tq5NRwp6SyEEO62aZOpINyjB3zzTYHED/DLwV84mnKU1X+tJtWW6vaQXDnUcx7wK9BWKZWolHpQa50F5JR03gF8o91V0lkIIbzJr7+aK/1bbjFJv2pVk/irFBzCOfrn0fSa3QuAIR2GEBoUWmAdV3NlA/e7i3j9J+AnVx2nsti3bx+vvfYa586dY9GiRVaHI4QoDbsd1q2D2bNh7lwIC4NGjeD5582jkFLpvx76lbd/fZvqVaoTHBDMmze96ZFQpbBbOTnTwzcyMpIuXbrQqlUrBg4ciM1mK3K/LVq0YObMmfle85bevlB8f1/p7SsqnexsWLAAOnaEv/0NFi6E556Do0dhxw6YPLnQxK+1ZvTK0YQEhJCckcy8O+dRu2ptj4Qsyb+cnOnh+/rrr7Nt2zZ2795NXFwccXFxxMbGMmDAgHyPEydOFHosb+ntC8X395XevqLS+Osv+Phj6NzZjNzx84OvvoKTJ+Gtt8yVfzE+3vQx/3fo/+hYtyNjrhnD35r/zUOBS/J3idL28M0Zx56QkIDWmlatWtGpUyeWLl2a71HXMeyrMK7q7VvSNjny9vbt2LFj7i+eovr7Sm9fUSls3AgDBkCLFvDEE+Z2z9dfQ0wM3HMPhJZ8z/7j3z/myWVPMqDNADY8uIHJN072QOAX+UxVz96zexd4bUiHITx25WOkZaZx2+yCPXxHdBnBiC4jOJV2iru+yT/JeM2INaU+dml7+A4fPpzMzEwOHz7M0qVLqV69epH7TEpK4oUXXmDr1q1MnjyZsWPHAq7r7Zvzi6iwbfL+0srb2xfInYX7xhtvFNrfV3r7Cp907BisWGFu4ezdC4sWmQ6AEyaYZN+qFTj6c5dG/Il4nl7+NNc1uY6Xrn+JAD/Pp2KfSf5WubSHb9OmTQvt4Vu3bl1iYmIAmDt3LpMmTeK774qe51a7dm2mT59e4PW8vX0vnYVbWK/epKSk3N6+QG5v35zkX1J/306dOvGvf/2LMWPGMGDAgBK7gwnhM7KzTcKfOhV+/NEUXwsMhOrVYcwYeOEFKMNMeK01Ty1/iupVqpOtsxn67VASnkxAOfHLwxUsS/5KqVBgLab2z9Ly7q+4K/WqgVWLXR5RNcKpK/0czvTwzdvJq3PnzrzzzjtOHy+Hq3r7FrXNJ598whdffAHk7+07fvx4brzxRl566aUyxy6EV0tPN7Nwo6MhNhYOHYJ69WDcOLjrLnNvv5xJesmuJaz+azWv9H6Fl9a8xCu9X/F44gfrSjqDqej5jauObwVnevi2a2eq9GmtmTNnDjfddFPufkaOHFnqY3qit+/DDz9caG/f0aNHs2XLFgDp7yt8h9bw3nt0GjsW2rSB0aNN0r/ySpg/Hw4ehFdfhS5dyp34AT7Y+AFNw5uSmZ2JQnF/l/vL/zWUgSUlnZVSfYDtQOHDWioAZ3v4zp49m65du9K9e3fS09OZNGkSAGlpaYSHhxMdHc2YMWPy/cVQGCt7+06cOJHx48cDSH9f4RvS001tnWefJfjYMejUCVatMm/cfvst/P3vEBTkssPtPLWT6P3RXBZxGZN/mcyNLW6kSXgTl+3fGZaUdAbCgFDML4QLwCCtdfYl+6rQJZ23bdvGxx9/nNumsTB2u53ff/+dSZMmceedd/Lggw+WuN97772XCRMm0Lp1a1eGWyAuKelcehKXc7wiLq2ps2YNLT75hJBjx/hrxAjiBw8mzM3VbD9K+IjFRxbzQrsX2HN+D4MaDiKiSvEDIcpzvoor6ezSRutAMyAuz/O7gM/yPL8P+CjP8xHAgJL2WxEbuGut9cyZM3VWVlaRy5OTk/W7776r//3vf+u5c+eWuL+MjAw9Z84cV4ZYZFyeJg3cXU/iKkR6utbffqt1z55ag9aXX671qlUeiSslI0WHTw7Xdy+626nt3NXA3dJx/lrr2doFb/Z6q9L08N2+fTuTJ09m586drF+/vth1pbevEOWwejW0bg133gn798Nnn8GWLXDjjR45/Py4+ZzLOEf0/mjWHyj+/7onSElni+XcFnrttdcsjkQIH/bpp/Dww+YN3R9/hL59IcBzgx211kz9Yyr1w+pzLOWYZff585KSzkII37Z6NTz2GPTvD1u3miqbHkz8AJuObGLL0S2EBYVxeb3LaVqjqUePXxgp6SyE8D0nT8KLL0Lz5ua2TuvWZthm1aqWhPN17NdU8a9CwukE7mx3pyUxXEpKOgshfEdysim09vrrkJpqrvIffxyGDSu0qqYnaK1ZsmsJ4cHhZNozeSrqKUviuJSUdxBCVFxam1LK33wDhw+bN3CzsuCOO0wZZcfkSivFn4znr7N/MbrnaLpFdqNGcA2rQwIk+QshKprMTNi8GdasgSVLTMesZs1Mhc3nnjOJ/6qrrI4y1/w4M0fpn1f9k8hqkRZHc5EkfyFExREbCzfdBDk9L9q3h+nTYdQo8PDExNI4knyEtza8RYNqDbwq8YMkfyFERZGYeHGkzjffQK9eUEzvC6slZyTT/dPu2Ow2hnYcanU4BUjyF0J4v8WLzTj9Cxdg/XpTXdPLDZo/iKMpR+nVtBdv9XnL6nAKsGSGr1KqnVJqulJqkVLqUSticBVnevg++mj+LzUqKoodO3YU2KezvXqL66cL+XvoSj9dUSFobRqorF4Nt98OAwdCgwbwf/9XIRL/FzFfsHr/ahpUa8CKYSvwU97XNNGSks5a6x1a60eAIcA1rorBCs708O3WrVvu8vT0dA4ePEibNm0K7NPZXr3F9dOF/D10pZ+u8GqJiXDffVCrFkRGmjH60dHw5pumdWKnTlZHWKxMeyZvb3ibh5Y8RKBfIKvuW0WVgColb2gBS0o6O5bdDvyID8wBKG0P37zJPzY2llatWhVZ+6eoXr2F9dQtqp8ukK+HbpUqVaSfrvAeiYnw3Xfw7rvmTdxGjcyInYULTeOUDz+En3+GAwfg3/92aWlld5m4diKjV46mT8s+7HtqH+3qWD/UtCiWlHTWWk/Os82PWusCBeqdKelcZcwY/GJjiw5Ma6ebMGR36kTGm2+Wat3hw4fndrxq0qQJNpuN9u3bk5CQkLtO06ZNCQsLy+3Yk5KSQr9+/ZgxY0ah+7Tb7bRq1Yq//vor3+uLFy9m1apVTJkyBTA9dc+ePcuQIUPYuHFj7nqRkZEcPXoUMH1/165dS+3atfN9XhQp6ewcics5KSkp1Dt5ki5PP02goyFQatOmJLdrR2bNmhy57TbSIz0/MsYV5+vODXeilGLhVQtd1p3LXSWd3f2Gb0PgUJ7niUCUUqo3MBioQhFX/lrrT4BPALp376579+6db/mOHTsu9rANCip2mFeW3U6As8ksKIigUtT2XrZsGRkZGdx6660cOHCADh06cOTIEWrWrJkbX04P3507d+Zu98QTT9CgQQOqVavGyJEjmTVrVoF957RYzNurt0ePHowfP55XX301t6duVlYWfn5+BXr65jxXShEWFka1atXyfV6UwvoDu1twcHCJTWbWrFnDpT8H3kDicsLu3SS8/z6tfvgBwsJg2TJo0YLQyEhCHatYVfKsvOcr1ZbK6bWnaVGzBTfccIPXxFUUS0b7aK3XAGtctsP33y928QU3JTNnevh26NAh37bbt2+nT58++Tp5LV++nIkTJ+b25y2sV2+bNm0K9NSVMs/C69lsZjz+6NG0stnMzNuFC+GS/xcV2aLtiwDo26KvxZGUjrvfgvbpks7O9PDN28AdID4+ng4dOrBlyxa2bt3Krl27ePPNN3OTfVG9eo8cOVKgp6700xVeSWtYuxb69YNq1eDpp6FvX35dsAC2b/epxA8XZ/I+fMXD5d9Zair06QPr1pV/X0WQks5l5GwP37zJ//Tp02itqVevHps2bSIqKorQ0NB8+y+qV29hPXWln67wGjYbzJ0Lf/sbVK8OvXubfrhPPmnG6i9ZQoYXT8wqj9+P/E4V/yp0qd+lfDvKzIShQ+F//3NJXEUqqsWXsw9gHnAUyMTc23/Q8fotwG5gL/BCWfZdEds4bt68WQ8bNqzYdZKTk/WoUaO03W7X48aN0+vWrctdNmjQIL1r1y53h1lkXJ4mbRxdz+NxJSRofcUVpj1i69ZaP/GE1rNmaZ2WZm1cpVSeuI6nHNf+E/319bOuL3sAFy5ovXKl1n37mnM4bVq546KYNo5S0tlNunXrxg033FDiyJnCOnnZbDYGDhxY6BwAIbzOli1mWGZOvfxFi2DwYKdH2FVk/1zxT/yUH9MGTCt55aLExJhbPbVqmfP5yCOuC7AQUt7BjUaOHFmm7aRXr/Bq2dkwZ455w/bQIYiLg9BQGDkSnn8emljfotCTbphzA2v2r+HlXi/Tvk77kje41OHDZvZyu3bwww+mxWRIiMvjvJT3zTkWQnivP/+E664ziX7fPmjY0EzSSkyEqVMrXeL/48gfrNm/hoiqEYy9dqzzOzhxwpSffvJJ86b4HXd4JPGDXPkLIUqSmmqu9Jcvh59+gpo14fPPYfhw8Ku8148ZWRncMd/M4p95+0znyjhs3GhmLa9bZ26PDRnipiiLJslfCFG4v/6Cr7+Gjz4yRdZatoSnnoLx48196Uruy5gvOXL+CA2qNeC2NreVfsMFC8xonvr1YdIkuO02S4rVSfIXQhS0cqWpnZ+VZYZtLlwI115rdVRew55tZ8LaCQA82OXBkks5nD9vbplde62pUjp5MjzxhJnlbBFLkr9SaiBwK1AdmKm1/tmKOIQQhUhIgL//HS67DP77X9MiUeSzeNdiEpMT6d+yP89d81zhKyUmmhLUa9aYv6CCguD4cXNP//nnPRpvYawq6fyD1voh4BHg766KQQhRDhkZMG0aXHmluQ+9eLEk/kIcPHuQ0StH07pWa/57z3+pXqW6WWC3mwfAiy9C48bm9s7cuTBggBnJ40XDXy0r6eww3rFcCGGVP/+Ef/7TjNx57DHo2hU2bDDllUUBAxcMZN+ZfXzQ/wMC/AJMGYt580xJ6uhos9I998AHH8CmTXD2LHz1FVxzjVclf0tKOgNvOB4rtdarithXqUs6l8SKEsWlIXFdJCWdXa+4uFRWFvWXL6fB4sVUS0ggOzCQUz17cvTWWznTvbtbk1RFPF8Au87vYureqcSci6FxSGPmt3qfRosWUXvDBkIPHCD5ssvY9a9/kVrKvOSquIpTXElnl5V3cPwSaQbE5Xl+F/BZnuf3AR8BTwGbgenAIyXttyKWdyiN4uLau3evHjlypL7zzjs9GJEh5R2cU6HiunBB608/NeUXQOuuXbX+6COtT52yNi4vUFxcJ1JO6Ij/RGi/iX469LVQveN4vNZt2mjt76/1TTdpPWOG1llZHo+rJBRT3sGSQbpa6w+11ldorR/RWk+3IgZXcaaHb2RkJF26dKFVq1YMHDgQm81W5H5btGjBzJkz873mzt6+eZ8/+OCDpdq/qGDOnYOoKHjoITMjd8kS2LwZHn8cimnuU9lprbn3u3s5lXaKYL8qrB8ezWV125tJbTt3mpFRDz9cbE8RbyQlncvJmR6+r7/+Otu2bWP37t3ExcURFxdHbGwsAwYMyPc4ceJEocdyZ2/fvM8v/aUjfEBGhplItH07fPutqcdz221edQ/aG2mtWX9wPSv3reSmtEi2vH+Brt//ZhbeeCO4+BaPJ7l7qGduSWdM0h8K3OPmY3pcUT18v/7669znMTExjBo1CjD3t7XWtGrVioYNG7J06dJSH2vgwIGMHTs292o9R2pqKkOGDCExMRG73c6LL77I999/n9vbt0+fPrz11luEhYWRkpKSr7fvyJEj2bVrV+7ze+65h7FjyzBVXXifCxfgm29g4kQzaeuzz0zRNVEqXWZ0gaQkqqfD4mlnqPqP5+CBB6wOyyVclvyVUvOA3kCEUioReFlrPVMp9QSwAvAHZmmt44vZTYX0/PPPk5GRwYEDB2jatCk2m419+/bRLM8wufj4eIYPH05mZiaHDx9m6dKlVK9evch9JiUl8cILL7B161YmT56cm4w7duzIpk2bCqy/fPlyGjRowI8//giY3r5RUVHExcWxbdu2AutPnz6d5cuXEx0dTURERO4+oqOjc9tHioqt/vLlMGiQGW1y+eWwYoUpGiZK5WTqSWKOxxBohxHJjam6ZxPUq2d1WC7jEyWdn1n+DNuObStyeVlGr3Sp34X3+79f4nrLli0jNTWVW2+9lfj4eJo2bcqpU6eoUaNG7jo5PXxjYmIAmDt3LpMmTeK7774rcr+1a9dm+vSCb4f4+/sTFBRUoM9up06d+Ne//sWYMWNye/ueOXOm9F+w8B3Z2fDMM1w2ZQr06gUvv2w+VuI6PE7JyoL0dDYe2QhApj88MPorn0r8IFU9yyWnh+/UqVPzdfIqrIdv3k5enTt3LvK+fmkU19u3U6dOjB8/nldeeaXM+xcVmNbwzDMwZQqH7roLVq2CG26QxF8Su53wmBj417+gdWv4xz9YvHMxAO0i2nFVU98rbeETtX1KukK/9CrZVS7t4btkielQmbeHb3BwMDExMbRr1w4wbyDNmTOHm266KXc/I0eOZNasWaU6ZnG9fWvVqsWwYcOoUaMGn332GY8//rj09q1M1q0zM0vXrYNnn2XvgAE0DvCJ/+LuNWwYLF5M15QUCArixzsv56MrdrByWwyBfoF8O+Tbkmv3VEByOVBGzvbwnT17Nl27dqV79+6kp6czadIkANLS0ggPDyc6OpoxY8bk+4uhMNLbVxRqzhxzhb93r6nC+fbbMpKnOPv2mb+SwNTTv/9+4l96CdvxI4zoup84dZKukV158foXaVennbWxuktREwC86VERJ3mVtofv+vXrda9evfQ0R7/Okniit69M8nKOpXFlZ2v9zjtmwtZNN2mdkuIdcRXDkrjS07VetEjrl17S+s47ta5aVet33y0Q1/c7vtdMQI9eMdrzMRbB63v4ivxK28N306ZNREVFERoaWuI+pbevyCc2Ft56C774wgzf/OoruOS9IAFkZpry1KtXm/c+WraEgQPh7oJjVF5d9yoAoUEl/3+s6Cy57aOUaqGUmqmUWmTF8T1l5MiRJY4y2r59O5MnT2bnzp2sX7++2HWlt6/INXWqGb45bx6MHWvq7Uviz8/8PQSBgaaO/mefQUoK7N5tflHWr59v9TUn17D56GYaVW/EuOvGWRS057hynP8sYABwQjsKuzle7w98gBnn/5nW+g2t9T7gQV9P/qXx6aefAvDaa69ZHImoMLKyTDOQnj1NmeA6dayOyDtoDUeOwIED5uOUKTBmjLnqnzixyM0ysjJ4YPEDzNs+D4Xim7u+IdA/sMj1fYUrb/vMxhRty61zkKekcx8gEdiklFqitd7uwuMKUbn88INpFPLxx5U78WdlQXKyaSl55gy0a2eapeRo0MDMcC5Gqi2VgQsGsmqfKS488/aZXN34andG7TUsKemstZ7seL5Ia31XEfuSks4WkZLOzvF0XF2efpoqJ0+y8Ysvii0m5qvnK/Svv2j+2WfU/u03znXowLYPPwSg6Zw5ZIaHkx4ZSWa1aqS2akV2UFCR+7Fl2xgXO46tZ7fyXJvnCM4O5oaGN5Q5LnfxtZLOtTHlnPcCY0vab0Uc7VMaEtdFMtqnlGJjzZ3st94qcVWfO1+rVml9/fXm669eXetnn9V6/vwyxzHsu2GaCejPNn9WvrjczKdG+2itkzAtHMu7H5+cfFHZaBf+9enzPv3U9IIdMcLqSNwvMxN+/tmUoY6IgB07zG2d1183JZTLUYY6KS2JebHzuL/z/YyPHk/D6g0JpnK9YV5hSzoHBweTlJQkiaOC01qTlJRUoFyFKER6uhnWOWiQSYa+LDbW9MAdMODim7VPPGHq548dW+7+A//d/V/s2s7iXYvJys6iY92OJW/kYypsSedGjRqRmJjIyZMnS1w3p8yCt5G4jODgYBo1auSx41VIhw7Bu++aNzYfesjqaNzrzBnzC87PzzSR79fP5YeYtmkaCkWt4FqsuG8Fjao3IoEElx/Hm1XYks6BgYE0b968VOuuWbOGrl27uuKwLiVxiVI5cQI6dIDz582wxRu8701Jlzl8GDp3NqN41qwxw1ldbEXCCn4/8jv1Quvx66hfqRta1+XHqAh8oqSzED7t669N4v/1V1OHxtfYbLBpE1xzjZl4deed5uHixK+1ZsXeFby+/nUA5g6aW2kTP/hIVU8hfNrcudC9u+8l/gsXTB/hN9807SX37oWGDWHGDJcf6nDyYe7+9m7WH1xP4+qN+bD/h/Rp0cflx6lIJPkL4c1iY2HrVnCMZfcFwceOwahRpiRFcjI0aQLz55vE7yYvr3mZXw/9SlhgGL+P+p361eqXvJGPk+QvhDdbsAACAmDoUKsjKZ9TpyA1FZo2RSsFixaZYnT33Qe9e7u12czxlON8EfMFWTqLezrdI4nfQZK/EN5s+3Zo06bilnHQGu6911zZ9+sHy5aRUa+eGa/voV7RUzdNxWa3UaNKDf7T5z8eOWZFIMlfCG+2fz80a2Z1FGX3v/+ZyqMPPZR/iKqHEn9GVgZTfp8CwHM9nyM8ONwjx60IJPkL4c3274erK3ChsVdfNQXWpkzxWMLP6/ud33Mm/QxVA6vyeI/HPX58byZtHIXwVufOmQlPFfXKf88eWLsW/v1vSxI/wIzNM2hRswUJTyZQI7iGJTF4K0n+QnirAwfMx4qa/Fu3hlmzLJuRHHcijjX71/BQt4eIrBZpSQzeTJK/EN5q/37zsSIlf5vN1OJZscI8f+ABqFrVoyFk2jN5bd1rXD3zahSKC5nF1/SvrKxq4xiqlJqjlPpUKXWvFTEI4fUqWvLPzjZDNydMMG/0WiDhdAI9Z/VkfPR4IsMi0WiiGkVZEou3c1nyV0rNUkqdUErFXfJ6f6XULqVUglLqecfLg4FFWuuHgNtdFYMQPmX/fnPVXBEqeGoN48fDN9/AG2/Afzw3pFJrzam0UyyMX8iVn15J/Il4agbXZM/pPdzd8W76tXR9YThfYEkbR0xp51jHanYXxlChXLBf4I8jf5BiSyHVlsqFrAvc1d40Nlt/YD07Tu3ILVmt0QT4BTCq2ygAVu5dyZ7Te/ItrxpYlZFdRwKwZNcS9p7ey4nUE5y3nSfFlgJAVMMosnU2fxz9gzMXzqC1Jltnk002YYFhdIvsRsLBBKYsmMJ523mydXbuMcKDw+lUtxMAm45sIi0zzRzbsbxWSK3c0ri/Jv5KRlYGmovx1a1al3Z12gHwy8FfyMrOync+6ofVp03tNgCs3b829/WcfQRlBBFli8Ku7fzfwf8rcD4bhzemaXhTbHYbvyX+VmD75jWa07B6Qy5kXmDz0c35lgG0rNmS+mH1SbGlsO3YtovbO76+NrXbEFE1gnMZ54g7cfEaJyUlhbCdYbSt3ZZaIbU4feE0O07tKBBf+zrtCa8Szsm0k+xJ2lNgeYe6HQgLCuN46nH2ndlHm/OHCB6YRcw0c04vr3c5IQEhHDl/hIPnDhaIv0v9LgT5B3E4+TCJyYmkpaVRNe7iLZdukd3w9/Pn4NmDHEs5VmD77g1Mw6cDZw9wIu1Evtj88KNrpCn2t+/MPk5fOH1x+yw7gcdO0Gn/Bfh3M/bWWMC5Dz7Jt+8qAVVoX6c9AFsPbEVvy1+KPSQwJPd7vztpd+7PVo6qgVVpVct07ttxagfnM86TYc8gIyuDDHsG2TobgM71OpNwOoErG17JuGvH0atZrwLnWRiWtHHE/CI4o7VeqpSar7UuMH2xpDaOzvCWdnaJaYk0DGmIUoolR5YwJWEKWTp/Alx1/Sr8lT/v7H6HpUeX5lsW7BfMsuuWATBpxyRWn1idb3mNwBo82vJRtp7ZyoakDSRnJbv3CyqEn+OPyWyyCyxTKPyUHwpV4OvO2dZfmbaEmTqzwHJ//AnwM9crGdkZBZYHqAAC/QLRWpOenV5geZBfEIEqEI0mzZ5WYHkVvyoE+QVh1/ZCl4f4hxCoArFrO6n21ALLQ/1DCfILIlNnkpKVUmB59YDqBPgFYMu2kZpVcPvwwHACVADp2emkZqVSN0VjV5AUahoW1QyqSYAKIM2eVuj2EUER+Pv5k5qVWujx6wXXww8/krOS822vMPuPDI5EKcXZzLOkZeX/+pVSNAhuAMAZ25kC5ydAQ2Ndg6ywapzKOMUFe/777IF+gTQIMdsfu3AMm7blWx7kF0RksHlT9mj6UWzZ+ZcH+wXnbn8o7RB2bc/9efJX/jQKacSIZiPoWqMrqfZUagXVKvD1l8Rb8sSl3NXG0d3j/BsCh/I8TwSigA+Bj5RStwL/LWxDrfUnwCcA3bt317179y5zEGvWrKE825fXgrgFvLzmZXYl7WLLw1voGtmVE/EnOHzhMEN7DiU8OJywoDBCA0NpV6cdfsqPLld1yb36yfnP6af8qBdWD4CuV3Ulw24SYJotjU+3fMqU36cweedk6lStw2X1LqNlzZZc0/gaGoc3pmZITSJCIqgVUgs/5Ze7b38/f/yUH374EeAXQGhQKOvXr+fqa65GKZW7zM/PJO1A/0AA7NkX/2BTSuXG6M7OalZ/H4vitrhq1YK774b/fFymzd16vrKy4M8/oUYNaNnSqU0r3fexnNwVl1VtHFOBB6w4tqetSFjBvd/dy+X1LmfKzVNoVN00LRnSYQh1T9ald7vehW5XI7hGseOSw4PDybRnMmvrLCasncCxlGPc3vZ2xl47lh4Ne+Cnyv52TpBfENWqVCt2HX8/72s871NOnPDeMf4nT8LAgbBhA9Sta0b2dOlidVTCSe5O/m5r41gRvPvru4z931g61u3I2hFrS0yopaW15rsd3zFu9Th2J+2mZ+OeLPx/C7m2ybUu2b/wAi+/bIqd9e9vdSQX2Wzw5ZdmKOeJEzB1qik1ffnlVkcmysDdQz1z2zgqpYIwbRyXuPmYljl07hAvR7/MlqNbALgs4jIe6/4Yy+5d5rLEv2b/Gq6aeRV3LbyLAL8AFg9dzC8P/CKJ35ds2mRq2j/5JHTqZG0s6emwe7f5PDUVnnnG9M9dswYefRSuvNKtFTmF+1TYNo7exJ5tZ8bmGfx75b9Jy0yjVkgtukV245bWt3BL61tccgyb3cYzy59h2h/TaFS9ETNvn8nwzsNz3wAVPsJuN0m1fn145RXPH19r00rx999NaYYvv4R69Ux10Zo1YcsWc4/fje/tCM+wpI2jUqo/8AHmF8JnWus3XBWHJySlJVG7am0AFsYv5IXVL7Dn9B76tOjDjAEzaF6zdL2FS6K1Zu+ZvSzdvZTPt31OzPEYnrv6OV654RVCAkNccgzhZWbMgM2bTevG6tVdv/+0NDh2DJKS4PRp80hKggcfhJAQeO450ygeIDDQ3Nu/776L27dq5fqYhCU8ftlY1Nh/rfV2Vx/LZrfx66FfWXl8JQf/PIg9245d28nW2bSt3ZaQwBCOnT/G3rN7sWXZyLBnkJ6ZTro9nb4t+1I1sCpbjmzJHbN++Pxh9p7Zy9n0syy5ewlB/kF8EfMFWmvGXTuOno17sv3kduJPxqO1RqOL/Rh3Io7jccfJ1tmcyzjHqbRTnEw9yakLpzhy/gi7Tu3iaMpRwIzhXvj/FubOA/AIrc193owMM7qjlmP43PHjkJJias/YbGY9Pz9o1OjilWNampnxqbX5GBQETZua7f/6y9xOyDvMOCTELNfatPPLyMi/PDSUaidPmklPu3dDZqbZb47wcHN8gPh4cwWdV40aF5dv21bw66xTx1SfzMoy3bPyLgNz9RsZaeKKd/zx6jh+o4QEk1Dr1TNfV3y82S5v/I0bmzdHU1Mvbp8jM9M89u2DxYtNA/PwcPgpzzXTFVeY/R8/bm4LgYk1Lc08br3VxLdlC8yZA2fO0Gn3bnOFfvq0aZfYti189hk8/TQF9O9vEvttt5k3mXv0MHEEBxdcV/gEK+4Z9AAStNb7AJRS84E7AJcn/xOpJ+g9p7d5stO5bd/77b1il98277Z8z1//5XXnDpDjkrlA4VXCiagaQf2w+vRt2ZcrG1xJ35Z9aV27ddn2X5jERHN1mZRkRm4cOmQqSH7xBQCt33sPbr/dJPicBFa/Phw9apJbv35mmJ+HXeHxI5ZOK4Bp08q/o8aNoWtX+OUXk8zzWrzYfE/++MMk6EutWmWS/969MHs21K5NUGCg+YXatKnpBgbQp0/ucmrVMo/atc0DTFctLxzuKFzPpZO8SnVApe4C+mutRzme3wdEaa2fuGS9ck/yyrBnsOrEKg4kHyA4KDh3zDoKmoQ0oYp/FVKyUjhjO0OACiDIL8hMBPILJDQgFH/lj8r557jH6crnaWlphFYNRaEIDQglPDCcQL/AMpzVYmhN/RUrqLt6NbGvvooOCqLVhx/S6Pvvc1fJDAsjo149Ns+Ygfb3p8bixdROTMQeEkJ2lSpkBwaCUvinpdFw8WKCzpwhvW5dznbpgj0kBK0U2VWqcL5tW1CKqvv345+aaq46/fzQQHZICCmO8eChf/2FX7pjEpbjvNirViXNMawxdN8+/DLNJK+cn86s0FDO1KlDcEgIoQkJ+GU5Jok53mzMDAsjvWFDUIqwPXsu/lXg2H9meDjp9U37vrA9e3Jfz9l/Zo0a2OrWBbud0H37Lp4/pUApbDVrYqtdG5WVRdWcapuO5Rk2GyoyksyaNVGZmVQ9ZKa26Dz3xW0REWSGh+OXkUHwkSP575krxdnOnbnQpAn+qakF9g9woVEjsqpVIyAlhZDDh3P3bw8OJjskBFt4ODooKN+33hcnLbmTL8ZV3CQvcxvCgw/gLsx9/pzn9wEfFbfNFVdcocsjOjq6XNu7i1vjys7WetUqrXv3Njcg2rfXev9+s2znTq1/+808T04uOa49e7SuU8fsZ8AArVevNvv3sEr5fSwHics5vhgX8IcuIq9acdunUo/994ikJHPbYONGUxRsxgwYNerikLy2bUu/rzNnzL6ys8298s6d3RKyEMKzrEj+uWP/MUl/KHCPBXH4rpo1zZt2Dz1kmmeX5027V181b0RGR0viF8KHeDz5a62zKsPYf486fhzGjIEdO+Dbb82olnIUwst14QJ8/jkMHgzXyiQyIXyJVVPz1gK/AquB/RbF4Buys2H4cJPsIyLyD1Msr2++Mbd9Hn3UdfsUQngFlyR/Jxu5gDRzcY2kJNMc++ef4f334ccf4eabXbf/6dPhssugl9REF8LXuOrKfzaQrwJVnslcNwPtgbuVUu0dixtxsdRzpW3mUm6nTsE778D/+3/wj3+4dt9JSfDbb2Z2p0zlF8LnuGycf2kbuWitJzvG9p/RlayZy6XKGpd/air20FDQmpDDh7ngGN/uyriabN/O5WPGsO299zjrJeV6fe376G4Sl3N8MS6PjPMHmgFxeZ4XOZ4fCAU+B6YB95a0bxnnn8eJE1q3bav16NEujydHdHS01hMmaK1UofMArOJT30cPkLic44txUd5x/kqpVUD9Qha9oLVe7MQvopxfOJWmmYtLJSebe/oHDhQ+xd+Vfv8d2reHaq4pRS2E8C6lSv5a65vKsG+ZzOVqTz1lJlotXgzXXee+42htkv/t8l68EL7KnUM9K1UjF7f7739NtcaxYwsW/XKx4GPHzJvJPXq49ThCCOu4aqjnPMy4/bZKqUSl1INa6ywgZzLXDuAbLZO5yk5r+Nvf4MUX3X6o6jscpUYl+Qvhs1wyw1c70chFOGnHDmjXztyCue02jwy7DI+JMXXzO3Z0+7GEENaQ5pveKjvbTN7q2BG++sq85qHx9rU2bYIbbjCdnIQQPkmSvzfR2szUveoqk3j79TMVOAcO9FwMe/cScuSIObYQwmdJ929vopTpspWdDaNHm7Z/f/87hIZ6LoYVK8zH/v2LX08IUaFJ8vcGW7aYfqw9esB//nOx7r4VVqzgQmQkIdKoWwifJrd9rKS1abTSsyc888zFRuhWSU2F1as5feWVUs9HCB8nV/5WOXKEDi+/DOvXm/vrX35pfcKdOxdSUjhx0000tDYSIYSbSfK3ws6dcPXV1E5NhTfeMPf3rbziB/M+w/vvQ/funJMhnkL4PEn+nnT2LNSoAW3awIMPsqlLF6KGDbM6KmPZMti92wwrtfovECGE21lyuamUaqGUmqmUWmTF8T0uPR3Gj4fmzeHECXOV//bbXGjUyOrIjOxseOklaNLE9AYQQvg8Szp5aa33aa0fdMWxvdq2bTByJERGwmuvwR13QIAX/rH15ZdmxNHrr8vELiEqCVdlotnAR8DcnBfydPLqAyQCm5RSS7TW2110TO+UnW2u7G02uOIKUyZh8GB44AHo3dvq6Ao6dw7GjYMrr4S7C63SIYTwQa6q7bPO0ckrrx5AgtZ6H4BSaj5wB+Cbyf/wYXj3XfjzT1OWISjIDOO86y5zn98baQ0PPwzHjsG331r/prMQwmPc2cbxLqC/1nqU4/l9QJTW+gmlVG3gNcxfBZ9prScXsr8K0cax7v/+R4MlSwiPM3e8jvXty56nnyY7ONjSuEojcskS2r73HnsffphDea76rY6rKBKXcyQu5/hiXOVu4wisAuIKedyRZ51mlLKNo7MPr23juHy51qB1+/Zajxun9b593hFXafz5p9bBwVr366e13Z5vkS+2s3Mnics5EpdzLG3jqKWTV36HDkHjxnDTTTBlCvzjHxXrjdIzZ0zNoBo1zMQuud0jRKUjnbyckZYGjzwCHTrA6dPg7w9PPFGxEv+5c2ZG8b59MG+eKR4nhKh0pJNXaZ05A336wCefwEMPQUiI1RE5b+tWuPpq83HRIu8cfSSE8Ajp5FUau3fDoEGQkADffGNG8FQ0W7aYxB8RAcuXw403Wh2REMJCXjjjyAt98AEcP25q3VfEq2WbzcwzqF3bXPXLrR4hKj15p68wWsPEibB0qXn+9tsmaVbExA+mdENMDEyfLolfCAFI8i/cm2/ChAkXu1qFhJjRPRXR22+br+ehh0wTeCGEQJJ/Qbt3m8R/553w4YdWR1N2WsOrr5py0UOGwNSpVkckhPAikvzzWrvWVLUMDjbj9ytqaePDh2HYMHjxRbjvPlO4zRsLygkhLGNZRlBKDQRuBaoDM7XWP1sVS66DB+HUKZg1y1TirIjWrYObbzY9gSdMMPf7K+ovMSGE27jsyr8MZZ1/0Fo/BDwC/N1VcZRJdrb5OHSomb07eLCl4ZTZ3r1mSGqTJqZb2MsvS+IXQhTKlbd9ZgP9876Qp6zzzUB74G6lVPtLthvvWMca2dkmYY4fb2bqVrRSBydPwnffwaOPQpcu5rWlS03jGCGEKILLMp3Weh1w+pKXc8s6a61tQE5ZZ5TxJrBMa73FVXE4JTvblDResgTq1LEkhDLbu9fc3omMNG9Oz55tPv7yC7RsaXV0Qggv57KSzuB0WeengPsxNYC2aa2nX7Ivt5Z09k9L47I33qDO+vXsv+8+9j/wgMdvkZS1VGvwsWN0efpp/C9c4Mjtt5N09dWktG5NdlCQpXG5m8TlHInLOb4YV7lLOmuLyzq7paTz9ddr7e+v9bvvlmvf5eF0qdZz57R+8UWta9bUukYNrbdudUdYPlna1p0kLudIXM6xtKSz45dExS/rnNNiEUxJ44kTK8as3dOnTW2eRx4xt3sGDoRJk6BjR6sjE0JUUO4e6plb1hmT9IcC97j5mIXLzoZnnoHMTPj4Y3jsMUvCcEpGBjz77MUJWo0amaGc111nbVxCiArPlUM9vbasc/iff5qr5ClTTG/dijCiJyYGrr3WJP7HHoMffoC4OEn8QgiXcNmVv/bWss6JiXR86SVTyvjrr02pA2+kNcTHw8qV5vHzz1CzpmmsXlHnHQghvJbvz/l/+GH8bDZYtgzatLE6msJpba7upzsGPLVpA08/DePGmTLMQgjhYr6f/N97j+3ffksnb0z8WsOOHaacxPTp8OST8NxzZoauEEK4ke8n/7ZtSerZ0+ooCjp3jk7PPw+//26e33+/aRoj5RiEEB7g+8nfm2htrvK/+gp27aLm8ePwxhumoXrnzpL4hRAeI8nfU44fN8M2v/7ajDzq0YM/e/Wi6zPPWB2ZEKISsmTMo1KqnVJqulJqkVLqUSti8Bitze2cli1hwQJ45RX480/4/nvO5RRiE0IID3NJ8i9DOecdWutHgCHANa6IwetoDbGxMGKEmVzWuzds324arFSEeQZCCJ/mqiw0GyfLOSulbgd+xMo5AO5w+DDcequZV3D55fDFFybhL1nivUNNhRCVjkvu+Wut1zkqeuaVW84ZQCmVU855u2ObJcASpdSPwNeuiMNyKSkwYAAkJMDdd0OPHnDLLdCggdWRCSFEPi4r6exkOefewGCgChCjtS7QzMXdJZ1dSdlsNFiyhAZLl1L10CFiX3+d01FRlsdVVhKXcyQu50hczrG0pDMWlnPW7irp7Cp//aX1lVdqDVr36KH199+XelNfLCHrThKXcyQu5/hiXJS3pLP2hXLO7vDjj3DffWC3m1aKgwZZHZEQQpSKO4ed5JZzVkoFYco5L3Hj8TwjMxNmzICoKHN/v2lTU2tfEr8QogJx1VBPry3n7FKbNpmZuI88AjYb/Oc/sGGD9MwVQlQ4rhrt453lnF1pzhzT7L1+fVNb//bbpRyDEKLCkvIOpZGYCP/4B/TsCYsWSZllIUSFJ1NNS+O110wbyM8/l8QvhPAJkvxLEh8PM2fCqFHQrJnV0QghhEtI8i/O3Llmlm716vDCC1ZHI4QQLiPJvygHDpir/e7dTRXOhg2tjkgIIVzGsuSvlApVSv2hlBpgVQzFevNN8/HLLyXxCyF8jiUlnR3GAN+44vgul5ho7vOPHAmNG5e8vhBCVDCWlHRWSvXBVPc84aLju9azz5p6/M9f+vtKCCF8g1UlnXsDoZhfCheUUj9prbNdEUu5LVxoHq+9JqN7hBA+y5KSznm2GQGc0lovLWR/Hi3pHHDuHI2/+YZG335LWtOmbJk6Fe3vX+ZjuiouK0hczpG4nCNxOUdKOpdDiSVR33pL62rVtFZK63vu0frQoXIdz2VxWUTico7E5RyJyzlS0tld1q+H0aPh5pvhrbegQwerIxJCCLdzZ22f3JLOmKQ/FLjHjcdzntYwZoxps7hoEVStanVEQgjhEZW7pPPixfDrrzBxoiR+IUSlUnlLOmdlwbhxcNllMGKE1dEIIYRHVd6SznPmwI4dpv1iQOU9DUKIyqly1vaJj4fx4+Gqq2DgQKujEUIIj6t8yT862vTf1RqmTZNuXEKISqny3e+YOBEiIkzv3QYNrI5GCCEsUbmu/Pfvh7VrTalmSfxCiErMkuSvlOqtlFqvlJqulOrtsQN/9ZX5OGyYxw4phBDeyKqSzhpIAYKBRFfEUKKUFDPC5/rrpWCbEKLSs6SkM7Bea30zpqb/RBfFUKTq8fHQti3s2QNPPunuwwkhhNezpKSzvli++QxQxRUxFKfRwoVgs5nZvFdd5e7DCSGE17OkpLNSajDQD6gBTNNarylkfy4r6XzF8OFkNGlC3Kuvlnkf7uCLJWTdSeJyjsTlHF+Mq3KXdE5P19l+flqPH1/2fbiJL5aQdSeJyzkSl3N8MS4qdUnnnTtR2dnQsaPHDy2EEN7KnUM9c0s6K6WCMCWdl7jxeIWLcwxAkuQvhBC5fL+kc2ws2QEB0KaNxw8thBDeyvdLOsfFkdakCWGBgZaGIYQQ3sT3yzvExpIqk7qEECIf307+yclw8CCpzZtbHYkQQngV307+KSkwdCjn5M1eIYTIx7eTf4MGMG8e57p0sToSIYTwKr6d/IUQQhTKkmYuSik/YBJQHTMDbY4VcQghRGVlVUnnOzAzfjPxVElnIYQQuawq6dwW2KC1fhZ41EUxCCGEKCWXJH+t9Trg9CUv55Z01lrbgJySzmCu9s84Pre7IgYhhBClZ1VJ56rAFCAN2Km1/riQ/bmspLMvlmp1J4nLORKXcyQu50hJ53LwxVKt7iRxOUfico7E5Rwp6SyEEMJl3DnUM7ekMybpDwXuKcuONm/efEopdaAcsUQAp8qxvbtIXM6RuJwjcTnHF+NqWtQClyR/R0nn3kCEUioReFlrPVMplVPS2R+YpctY0llrXaec8f2hi7rvZSGJyzkSl3MkLudUtrh8v6SzEEKIAqS8gxBCVEKVJfl/YnUARZC4nCNxOUfick6listl4/yFEEJUHJXlyl8IIUQekvyFEKIS8unkX0xVUU/H0VgpFa2U2q6UildKPe14fYJS6rBSapvjcYsFse1XSsU6jv+H47VaSqmVSqk9jo81PRxT2zznZJtSKlkp9YxV56uwqrVFnSNlfOj4mYtRSnXzYExvKaV2Oo77vVKqhuP1ZkqpC3nO23R3xFRCbEV+75RSYx3na5dSqp+H41qQJ6b9Sqltjtc9cs6KyQ3u//kqaupvRX9g5hbsBVoAQcCfQHuLYokEujk+rwbsxlQ6nQA8Z/F52g9EXPLaf4DnHZ8/D7xp8ffxGGayiiXnC7ge6Eb+8iWFniPgFmAZoICrgI0ejKkvEOD4/M08MTXLu55F56vQ753j/8GfQBWgueP/rL+n4rpk+TvAS548Z8XkBrf/fPnylX9xVUU9Smt9VGu9xfH5eWAH0NCKWErpDiCnwc4cYKB1oXAjsFdrXZ4Z3uWiC69aW9Q5ugOYq43fgBpKqUhPxKS1/llrneV4+humpIrHFXG+inIHMF9rnaG1/gtIwPzf9WhcSikFDAHmuePYxcRUVG5w+8+XLyf/hsChPM8T8YKEq0z1067ARsdLTzj+fJvl6dsrDhr4WSm1WZlKqgD1tNZHHZ8fA+pZEFeOoeT/D2n1+cpR1Dnylp+7kZgrxBzNlVJblVJrlVLXWRAPFP6985bzdR1wXGu9J89rHj1nl+QGt/98+XLy9zpKqTDgW+AZrXUyMA1oCXQBjmL+7PS0a7XW3TBNdx5XSl2fd6E2f2taMh5YKRUE3A4sdLzkDeerACvPUWGUUi8AWcBXjpeOAk201l2BZ4GvlVLVPRyWV37v8rib/BcZHj1nheSGXO76+fLl5O9VVUWVUoGYb+5XWuvvALTWx7XWdq11NvApbvpztzha68OOjyeA7x0xHM/5U9Lx8YSn43K4GdiitT7uiNHy85VHUefI0p87pdQIYABwryNp4LilkuT4fDPmvnobT8XkOG5R3zvL/58qpQKAwcCCnNc8ec4Kyw144OfLl5N/blVRxxXkUGCJFYE47ifOBHZord/N83ree3WDMD0SPBlXqFKqWs7nmDcM4zDn6X7HavcDiz0ZVx75rsasPl+XKOocLQGGO0ZlXAWcy/Pnu1sppfoD/wZu11qn5Xm9jjJtVVFKtQBaA/s8EVOeGIr63i0BhiqlqihTAbg18LsnYwNuwjSVyu0n7qlzVlRuwBM/X+5+N9vKB+ad8d2Y39ovWBjHtZg/22KAbY7HLcAXQKzj9SVApIfjaoEZafEnEJ9zjoDawP+APZhGPrUsOGehQBIQnuc1S84X5hfQUSATc4/1waLOEWYUxseOn7lYoLsHY0rA3A/O+Rmb7lj3Tsf3dxuwBbjNgvNV5PcOeMFxvnYBN3syLsfrs4FHLlnXI+esmNzg9p8vKe8ghBCVkC/f9hFCCFEESf5CCFEJSfIXQohKSJK/EEJUQpL8hRCiEpLkL4QQlZAkfyGEqIT+P72pMxwpRyqiAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "### Load Data ###\n",
    "\n",
    "# non-stiff problem \n",
    "v_hess = np.loadtxt(\"prove_stiffness/max_cor_100/hess_eigvals.txt\")\n",
    "v_approx_hess = np.loadtxt(\"prove_stiffness/max_cor_100/approx_hess_eigvals.txt\")\n",
    "\n",
    "# stiff problem\n",
    "v_hess_stiff = np.loadtxt(\"prove_stiffness/max_cor_100/hess_eigvals_stiff.txt\")\n",
    "v_approx_hess_stiff = np.loadtxt(\"prove_stiffness/max_cor_100/approx_hess_eigvals_stiff.txt\")\n",
    "\n",
    "### Plotting ###\n",
    "\n",
    "fig,ax = plt.subplots()\n",
    "\n",
    "# non-stiff problem\n",
    "plt.plot(v_hess, '--', label = '$\\lambda(H_k)$ non-stiff', color = 'red')\n",
    "plt.plot(v_approx_hess, '--', label = '$\\lambda(B_k^{-1})$ non-stiff', color = 'green')\n",
    "\n",
    "# stiff problem\n",
    "plt.plot(v_hess_stiff, label = '$\\lambda(H_k)$ stiff', color = 'red')\n",
    "plt.plot(v_approx_hess_stiff, label = '$\\lambda(B_k^{-1})$ stiff', color = 'green')\n",
    "\n",
    "ax.set_yscale('symlog')\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "\n",
    "# plt.savefig('prove_stiffness/max_cor_100/eigenvalues_compare_max_cor_100.png', dpi = 500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "### Load Data ###\n",
    "\n",
    "# non-stiff problem \n",
    "v_hess = np.loadtxt(\"prove_stiffness/max_cor_200/hess_eigvals.txt\")\n",
    "v_approx_hess = np.loadtxt(\"prove_stiffness/max_cor_200/approx_hess_eigvals.txt\")\n",
    "\n",
    "# stiff problem\n",
    "v_hess_stiff = np.loadtxt(\"prove_stiffness/max_cor_200/hess_eigvals_stiff.txt\")\n",
    "v_approx_hess_stiff = np.loadtxt(\"prove_stiffness/max_cor_200/approx_hess_eigvals_stiff.txt\")\n",
    "\n",
    "### Plotting ###\n",
    "\n",
    "fig,ax = plt.subplots()\n",
    "\n",
    "# non-stiff problem\n",
    "plt.plot(v_hess, '--', label = '$\\lambda(H_k)$ non-stiff', color = 'red')\n",
    "plt.plot(v_approx_hess, '--', label = '$\\lambda(B_k^{-1})$ non-stiff', color = 'green')\n",
    "\n",
    "# stiff problem\n",
    "plt.plot(v_hess_stiff, label = '$\\lambda(H_k)$ stiff', color = 'red')\n",
    "plt.plot(v_approx_hess_stiff, label = '$\\lambda(B_k^{-1})$ stiff', color = 'green')\n",
    "\n",
    "ax.set_yscale('symlog')\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "\n",
    "# plt.savefig('prove_stiffness/max_cor_200/eigenvalues_compare_max_cor_200.png', dpi = 500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "### Load Data ###\n",
    "\n",
    "# non-stiff problem \n",
    "v_hess = np.loadtxt(\"prove_stiffness/max_cor_500/hess_eigvals.txt\")\n",
    "v_approx_hess = np.loadtxt(\"prove_stiffness/max_cor_500/approx_hess_eigvals.txt\")\n",
    "\n",
    "# stiff problem\n",
    "v_hess_stiff = np.loadtxt(\"prove_stiffness/max_cor_500/hess_eigvals_stiff.txt\")\n",
    "v_approx_hess_stiff = np.loadtxt(\"prove_stiffness/max_cor_500/approx_hess_eigvals_stiff.txt\")\n",
    "\n",
    "### Plotting ###\n",
    "\n",
    "fig,ax = plt.subplots()\n",
    "\n",
    "# non-stiff problem\n",
    "plt.plot(v_hess, '--', label = '$\\lambda(H_k)$ non-stiff', color = 'red')\n",
    "plt.plot(v_approx_hess, '--', label = '$\\lambda(B_k^{-1})$ non-stiff', color = 'green')\n",
    "\n",
    "# stiff problem\n",
    "plt.plot(v_hess_stiff, label = '$\\lambda(H_k)$ stiff', color = 'red')\n",
    "plt.plot(v_approx_hess_stiff, label = '$\\lambda(B_k^{-1})$ stiff', color = 'green')\n",
    "\n",
    "ax.set_yscale('symlog')\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "\n",
    "# plt.savefig('prove_stiffness/max_cor_500/eigenvalues_compare_max_cor_500.png', dpi = 500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "s1 = np.loadtxt('prove_stiffness/max_cor_10/non_stiff.txt', comments = \"#\", delimiter = \" \", unpack = False)\n",
    "s2 = np.loadtxt('prove_stiffness/max_cor_10/stiff.txt', comments = \"#\", delimiter = \" \", unpack = False)\n",
    "s3 = np.loadtxt('prove_stiffness/max_cor_100/non_stiff.txt', comments = \"#\", delimiter = \" \", unpack = False)\n",
    "s4 = np.loadtxt('prove_stiffness/max_cor_100/stiff.txt', comments = \"#\", delimiter = \" \", unpack = False)\n",
    "s5 = np.loadtxt('prove_stiffness/max_cor_200/non_stiff.txt', comments = \"#\", delimiter = \" \", unpack = False)\n",
    "s6 = np.loadtxt('prove_stiffness/max_cor_200/stiff.txt', comments = \"#\", delimiter = \" \", unpack = False)\n",
    "s7 = np.loadtxt('prove_stiffness/max_cor_500/non_stiff.txt', comments = \"#\", delimiter = \" \", unpack = False)\n",
    "s8 = np.loadtxt('prove_stiffness/max_cor_500/stiff.txt', comments = \"#\", delimiter = \" \", unpack = False)\n",
    "\n",
    "fig,ax = plt.subplots()\n",
    "\n",
    "plt.semilogy(s1[:,3], '--', color = 'blue', label = 'm = 10, Non-stiff')\n",
    "plt.semilogy(s2[:,3], color = 'blue', label = 'Stiff')\n",
    "\n",
    "plt.semilogy(s3[:,3], '--', color = 'black', label = 'm = 100, Non-stiff')\n",
    "plt.semilogy(s4[:,3], color = 'black', label = 'Stiff')\n",
    "\n",
    "plt.semilogy(s5[:,3], '--', color = 'orange', label = 'm = 200, Non-stiff')\n",
    "plt.semilogy(s6[:,3], color = 'orange', label = 'Stiff')\n",
    "\n",
    "plt.semilogy(s7[:,3], '--', color = 'green', label = 'm = 500, Non-stiff')\n",
    "plt.semilogy(s8[:,3], color = 'green', label = 'Stiff')\n",
    "\n",
    "plt.xlabel('iterations')\n",
    "plt.ylabel('Error')\n",
    "plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')\n",
    "plt.grid()\n",
    "\n",
    "plt.savefig('prove_stiffness/compare_error_convergence_difference_with_m=max_cor.png', dpi = 500, bbox_inches='tight')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
